home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / XCMDs and XFCNs / HCGestalt XFCN 1.1.1 / HCGestalt.c next >
Encoding:
C/C++ Source or Header  |  1994-05-06  |  7.8 KB  |  334 lines  |  [TEXT/R*ch]
  1. /****************************************************************************
  2. *
  3. *  HCGestalt XFCN v1.1.1
  4. *
  5. *  All source code © 1992-94 Best Before Yesterday (Alex Metcalf)
  6. *  All rights reserved
  7. *
  8. *
  9. *  This source code is being distributed to allow new programmers to
  10. *  see how to get started with writing an external for Hypercard.
  11. *  I know it's not perfect code (I'm sure people can suggest ways to
  12. *  optimize it), but I think it's a good example of how you can receive
  13. *  parameters, as well as return a result to Hypercard.
  14. *
  15. *  This code is for THINK C. Make a project, and include the files:
  16. *  "ANSI-A4", "HyperXLib", and "MacTraps". You'll probably need all three
  17. *  of these when you write your own external.
  18. *
  19. *  Please distribute only unmodified versions of this code.
  20. *  Contact me if you wish to use this XFCN in your stacks.
  21. *
  22. *  Alex Metcalf
  23. *  alex@metcalf.demon.co.uk
  24. *
  25. *  UK Fax:        (0570) 45636
  26. *  US/Canada Fax: 011 44 570 45636
  27. *
  28. ****************************************************************************/
  29.  
  30.  
  31. /*****
  32. *
  33. * A quick note about memory:
  34. *
  35. * The most common problem in Hypercard externals occurs when you don't
  36. * "tidy up after yourself". This means that you allocate some memory
  37. * somewhere, and then don't get rid of it when you leave. Not good! Although
  38. * this only causes problems when the user calls your XCMD lots of times,
  39. * it's much better to find the leak and plug it. The way to check for a
  40. * leak is to make an empty stack, put your XCMD or XFCN in the stack, and
  41. * put the following into the card script:
  42. *
  43. * on idle
  44. *    MyXCMD "parameter 1"
  45. *    put the heapspace
  46. * end idle
  47. *
  48. * or if it's an XFCN:
  49. *
  50. * on idle
  51. *    get MyXFCN "parameter 1"
  52. *    put the heapspace
  53. * end idle
  54. *
  55. * Then move the mouse over the button and watch the number in the msg box.
  56. * If it's going down, you have a memory leak! Check through your code for
  57. * any times you use NewPtr() or NewHandle(), and make sure you're disposing
  58. * them if you have to. I've only used NewPtr once in this code, and I didn't
  59. * dispose it because I'm giving it back to Hypercard. Another way you can
  60. * lose memory is if you use a toolbox routine which allocates memory, and
  61. * you don't bother to get rid of it.
  62. *
  63. *****/
  64.  
  65.  
  66. #include <HyperXCmd.h>
  67. #include <gestaltEqu.h>
  68.  
  69. /*****
  70. *
  71. * If you want to use global variables in your code, then you need
  72. * to include:
  73. *
  74. * #include <SetUpA4.h>
  75. *
  76. * Then, right at the beginning of main(), type in "SetUpA4 ();". Then, right
  77. * at the end of main(), type in "RestoreA4 ();". You'll then be able to use
  78. * global variables.
  79. *
  80. * Note you'll also need to put RestoreA4 right before any "return" commands
  81. * you have in your main().
  82. * 
  83. *****/
  84.  
  85.  
  86. /*****
  87. *
  88. * To return a result to Hypercard, you need to give Hypercard a handle
  89. * to a C string which you have made.
  90. *
  91. *****/
  92.  
  93. void ReturnValue (XCmdPtr paramPtr, char *tStringPtr)
  94. {
  95.     Handle    tStringHandle;
  96.     
  97.     tStringHandle = NewHandle (256);
  98.     if (tStringHandle == nil)
  99.     {
  100.         SysBeep (1);
  101.         return;
  102.     }
  103.     
  104.     MoveHHi (tStringHandle);
  105.     HLock (tStringHandle);
  106.     strcpy ((char *) *tStringHandle, tStringPtr);
  107.     
  108.     paramPtr->returnValue = tStringHandle;
  109. }
  110.  
  111. /*****
  112. *
  113. * UpperCase is a little routine I made to convert the user's parameters
  114. * into upper case. Otherwise, if they used a parameter "one" and you only
  115. * checked for "One", for example, they'd wonder why it wasn't working.
  116. *
  117. * I think there's a command in C for converting a string to upper case,
  118. * but I didn't know that when I wrote this. :-)
  119. *
  120. *****/
  121.  
  122. UpperCase (char *tString)
  123. {
  124.     short        i, tLength;
  125.     
  126.     tLength = strlen (tString);
  127.     for (i=0;i<=tLength;i++)
  128.     {
  129.         if ( (tString[i] >= 'a') && (tString[i] <= 'z') )
  130.         {
  131.             tString[i] -= 32;
  132.         }
  133.     }
  134. }
  135.  
  136.  
  137. /*****
  138. *
  139. * Great little piece of code to check for a system version you require.
  140. * For example, if your XCMD needs System 7.0.1 or later, replace the
  141. * 604 with 701. This XFCN, obviously, requires System 6.0.4 or later.
  142. *
  143. *****/
  144.  
  145.  
  146. Boolean SystemOK (void)
  147. {
  148.     OSErr         myStatus;
  149.     SysEnvRec    myEnvData;
  150.     
  151.     myStatus = SysEnvirons (1, &myEnvData);
  152.     if ((myStatus != noErr) ||
  153.         (myEnvData.systemVersion < 0x604))
  154.     {
  155.         return false;
  156.     } else
  157.     {
  158.         return true;
  159.     }
  160. }
  161.  
  162. /*****
  163. *
  164. * Used for checking for a Gestalt feature.
  165. *
  166. *****/
  167.  
  168. char * CheckMyBit (long *tFeature, short tTestBit)
  169. {
  170.     if (BitTst (tFeature, 31-tTestBit) == true)
  171.     {
  172.         return "true";
  173.     } else
  174.     {
  175.         return "false";
  176.     }
  177. }
  178.  
  179. /*****
  180. *
  181. * A small but very important bit of code, which reads in the parameters
  182. * that the programmer gives you. For the first parameter, use 'params[0]',
  183. * for the second use 'params[1]', and so on. You can check the number
  184. * of parameters that the user gave you by checking "paramPtr->paramCount".
  185. *
  186. *****/
  187.  
  188. void LoadParams (XCmdPtr paramPtr, char *tSelectorType)
  189. {
  190.     strcpy (tSelectorType, *(paramPtr->params[0]));
  191. }
  192.  
  193. /*****
  194. *
  195. * The majority of this code deals with the Gestalt Manager.
  196. * If you're only interested in the 'core' of the XCMD, skip
  197. * right down to the bottom, to main().
  198. *
  199. * I've removed most of the checks, but I've left one or two so you
  200. * get an idea of what's happening.
  201. *
  202. *****/
  203.  
  204. void HCGAddressingMode (char *tReturnStr)
  205. {
  206.     long    tFeature;
  207.     int        tError;
  208.     
  209.     tError = Gestalt (gestaltAddressingModeAttr, &tFeature);
  210.     if (tError != noErr)
  211.     {
  212.         strcpy (tReturnStr, "Error");
  213.         return;
  214.     }
  215.     strcpy (tReturnStr, CheckMyBit (&tFeature,
  216.         gestalt32BitAddressing));
  217.     
  218.     if (strcmp (tReturnStr, "true") == 0)
  219.     {
  220.         strcpy (tReturnStr, "32 Bit Addressing");
  221.     } else
  222.     {
  223.         strcpy (tReturnStr, "24 Bit Addressing");
  224.     }
  225. }
  226.  
  227. void HCGMachineType (char *tReturnStr)
  228. {
  229.     long    tFeature;
  230.     int        tError;
  231.     
  232.     tError = Gestalt (gestaltMachineType, &tFeature);
  233.     if (tError != noErr)
  234.     {
  235.         strcpy (tReturnStr, "Error");
  236.         return;
  237.     }
  238.     GetIndString ((StringPtr) tReturnStr,
  239.         kMachineNameStrID, tFeature);
  240.     PtoCstr ((StringPtr) tReturnStr);
  241. }
  242.  
  243. void HCGROMSize (char *tReturnStr)
  244. {
  245.     long    tFeature;
  246.     int        tError;
  247.     
  248.     tError = Gestalt (gestaltROMSize, &tFeature);
  249.     if (tError != noErr)
  250.     {
  251.         strcpy (tReturnStr, "Error");
  252.         return;
  253.     }
  254.     NumToString (tFeature, (StringPtr) tReturnStr);
  255.     PtoCstr ((StringPtr) tReturnStr);
  256. }
  257.  
  258. void GetGestalt (char *selector, char *tReturnStr)
  259. {
  260.     UpperCase (selector);
  261.     
  262.     if (strcmp (selector, "ADDRESSING MODE")==0)
  263.     {
  264.         HCGAddressingMode (tReturnStr);
  265.         return;
  266.     }
  267.     
  268.     if (strcmp (selector, "MACHINE TYPE")==0)
  269.     {
  270.         HCGMachineType (tReturnStr);
  271.         return;
  272.     }
  273.     
  274.     strcpy (tReturnStr, "Error: selector type unknown.");
  275. }
  276.  
  277. /*****
  278. *
  279. * main() is the first bit of code that is executed when the user calls your
  280. * external. The only parameter is something called an XCmdPtr: this is the
  281. * information that Hypercard passes you, such as what parameters the user
  282. * entered and stuff like that. Don't lose it! You need the same information
  283. * to give a result back to the user. If you want to know more about it,
  284. * look in the header "HyperXCmd.h".
  285. *
  286. * I've started by checking the system version to make sure Gestalt's available.
  287. * I then used paramPtr->paramCount to make sure that they only entered one
  288. * parameter: if they didn't, then I tell them how to do it properly! Then,
  289. * LoadParams () loads  the parameter, and GetGestalt goes away and figures
  290. * out what they want. If any of my Gestalt stuff returned an error message,
  291. * then I convert it to something more meaningful for the user. Finally, I
  292. * use ReturnValue to give the result back to the user. Simple!
  293. *
  294. *****/
  295.     
  296. pascal void main (XCmdPtr paramPtr)
  297. {
  298.     char    tReturnStr[256], selector[256];
  299.     
  300.     *tReturnStr = 0;
  301.     
  302.     if (!SystemOK ())
  303.     {
  304.         strcpy (tReturnStr, "Error: HCGestalt requires System 6.0.4"
  305.             " or later.");
  306.         ReturnValue (paramPtr, tReturnStr);
  307.         return;
  308.     }
  309.  
  310.     if ( !(paramPtr->paramCount==1) )
  311.     {
  312.         strcpy (tReturnStr, "Syntax: HCGestalt <selector type>");
  313.         ReturnValue (paramPtr, tReturnStr);
  314.         return;
  315.     }
  316.     
  317.     LoadParams (paramPtr, selector);
  318.     GetGestalt (selector, tReturnStr);
  319.     
  320.     if (strcmp(tReturnStr, "Error")==0)
  321.     {
  322.         strcpy (tReturnStr, "Error: Gestalt Manager returned"
  323.             " an error.");
  324.     }
  325.     
  326.     ReturnValue (paramPtr, tReturnStr);
  327. }
  328.  
  329. /*****
  330. *
  331. * The end!
  332. *
  333. *****/
  334.